home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / lib / python2.5 / webbrowser.py < prev    next >
Encoding:
Python Source  |  2007-05-02  |  20.1 KB  |  652 lines
  1. #! /usr/bin/python2.5
  2. """Interfaces for launching and remotely controlling Web browsers."""
  3.  
  4. import os
  5. import shlex
  6. import sys
  7. import stat
  8. import subprocess
  9. import time
  10.  
  11. __all__ = ["Error", "open", "open_new", "open_new_tab", "get", "register"]
  12.  
  13. class Error(Exception):
  14.     pass
  15.  
  16. _browsers = {}          # Dictionary of available browser controllers
  17. _tryorder = []          # Preference order of available browsers
  18.  
  19. def register(name, klass, instance=None, update_tryorder=1):
  20.     """Register a browser connector and, optionally, connection."""
  21.     _browsers[name.lower()] = [klass, instance]
  22.     if update_tryorder > 0:
  23.         _tryorder.append(name)
  24.     elif update_tryorder < 0:
  25.         _tryorder.insert(0, name)
  26.  
  27. def get(using=None):
  28.     """Return a browser launcher instance appropriate for the environment."""
  29.     if using is not None:
  30.         alternatives = [using]
  31.     else:
  32.         alternatives = _tryorder
  33.     for browser in alternatives:
  34.         if '%s' in browser:
  35.             # User gave us a command line, split it into name and args
  36.             browser = shlex.split(browser)
  37.             if browser[-1] == '&':
  38.                 return BackgroundBrowser(browser[:-1])
  39.             else:
  40.                 return GenericBrowser(browser)
  41.         else:
  42.             # User gave us a browser name or path.
  43.             try:
  44.                 command = _browsers[browser.lower()]
  45.             except KeyError:
  46.                 command = _synthesize(browser)
  47.             if command[1] is not None:
  48.                 return command[1]
  49.             elif command[0] is not None:
  50.                 return command[0]()
  51.     raise Error("could not locate runnable browser")
  52.  
  53. # Please note: the following definition hides a builtin function.
  54. # It is recommended one does "import webbrowser" and uses webbrowser.open(url)
  55. # instead of "from webbrowser import *".
  56.  
  57. def open(url, new=0, autoraise=1):
  58.     for name in _tryorder:
  59.         browser = get(name)
  60.         if browser.open(url, new, autoraise):
  61.             return True
  62.     return False
  63.  
  64. def open_new(url):
  65.     return open(url, 1)
  66.  
  67. def open_new_tab(url):
  68.     return open(url, 2)
  69.  
  70.  
  71. def _synthesize(browser, update_tryorder=1):
  72.     """Attempt to synthesize a controller base on existing controllers.
  73.  
  74.     This is useful to create a controller when a user specifies a path to
  75.     an entry in the BROWSER environment variable -- we can copy a general
  76.     controller to operate using a specific installation of the desired
  77.     browser in this way.
  78.  
  79.     If we can't create a controller in this way, or if there is no
  80.     executable for the requested browser, return [None, None].
  81.  
  82.     """
  83.     cmd = browser.split()[0]
  84.     if not _iscommand(cmd):
  85.         return [None, None]
  86.     name = os.path.basename(cmd)
  87.     try:
  88.         command = _browsers[name.lower()]
  89.     except KeyError:
  90.         return [None, None]
  91.     # now attempt to clone to fit the new name:
  92.     controller = command[1]
  93.     if controller and name.lower() == controller.basename:
  94.         import copy
  95.         controller = copy.copy(controller)
  96.         controller.name = browser
  97.         controller.basename = os.path.basename(browser)
  98.         register(browser, None, controller, update_tryorder)
  99.         return [None, controller]
  100.     return [None, None]
  101.  
  102.  
  103. if sys.platform[:3] == "win":
  104.     def _isexecutable(cmd):
  105.         cmd = cmd.lower()
  106.         if os.path.isfile(cmd) and cmd.endswith((".exe", ".bat")):
  107.             return True
  108.         for ext in ".exe", ".bat":
  109.             if os.path.isfile(cmd + ext):
  110.                 return True
  111.         return False
  112. else:
  113.     def _isexecutable(cmd):
  114.         if os.path.isfile(cmd):
  115.             mode = os.stat(cmd)[stat.ST_MODE]
  116.             if mode & stat.S_IXUSR or mode & stat.S_IXGRP or mode & stat.S_IXOTH:
  117.                 return True
  118.         return False
  119.  
  120. def _iscommand(cmd):
  121.     """Return True if cmd is executable or can be found on the executable
  122.     search path."""
  123.     if _isexecutable(cmd):
  124.         return True
  125.     path = os.environ.get("PATH")
  126.     if not path:
  127.         return False
  128.     for d in path.split(os.pathsep):
  129.         exe = os.path.join(d, cmd)
  130.         if _isexecutable(exe):
  131.             return True
  132.     return False
  133.  
  134.  
  135. # General parent classes
  136.  
  137. class BaseBrowser(object):
  138.     """Parent class for all browsers. Do not use directly."""
  139.  
  140.     args = ['%s']
  141.  
  142.     def __init__(self, name=""):
  143.         self.name = name
  144.         self.basename = name
  145.  
  146.     def open(self, url, new=0, autoraise=1):
  147.         raise NotImplementedError
  148.  
  149.     def open_new(self, url):
  150.         return self.open(url, 1)
  151.  
  152.     def open_new_tab(self, url):
  153.         return self.open(url, 2)
  154.  
  155.  
  156. class GenericBrowser(BaseBrowser):
  157.     """Class for all browsers started with a command
  158.        and without remote functionality."""
  159.  
  160.     def __init__(self, name):
  161.         if isinstance(name, basestring):
  162.             self.name = name
  163.         else:
  164.             # name should be a list with arguments
  165.             self.name = name[0]
  166.             self.args = name[1:]
  167.         self.basename = os.path.basename(self.name)
  168.  
  169.     def open(self, url, new=0, autoraise=1):
  170.         cmdline = [self.name] + [arg.replace("%s", url)
  171.                                  for arg in self.args]
  172.         try:
  173.             if sys.platform[:3] == 'win':
  174.                 p = subprocess.Popen(cmdline)
  175.             else:
  176.                 p = subprocess.Popen(cmdline, close_fds=True)
  177.             return not p.wait()
  178.         except OSError:
  179.             return False
  180.  
  181.  
  182. class BackgroundBrowser(GenericBrowser):
  183.     """Class for all browsers which are to be started in the
  184.        background."""
  185.  
  186.     def open(self, url, new=0, autoraise=1):
  187.         cmdline = [self.name] + [arg.replace("%s", url)
  188.                                  for arg in self.args]
  189.         try:
  190.             if sys.platform[:3] == 'win':
  191.                 p = subprocess.Popen(cmdline)
  192.             else:
  193.                 setsid = getattr(os, 'setsid', None)
  194.                 if not setsid:
  195.                     setsid = getattr(os, 'setpgrp', None)
  196.                 p = subprocess.Popen(cmdline, close_fds=True, preexec_fn=setsid)
  197.             return (p.poll() is None)
  198.         except OSError:
  199.             return False
  200.  
  201.  
  202. class UnixBrowser(BaseBrowser):
  203.     """Parent class for all Unix browsers with remote functionality."""
  204.  
  205.     raise_opts = None
  206.     remote_args = ['%action', '%s']
  207.     remote_action = None
  208.     remote_action_newwin = None
  209.     remote_action_newtab = None
  210.     background = False
  211.     redirect_stdout = True
  212.  
  213.     def _invoke(self, args, remote, autoraise):
  214.         raise_opt = []
  215.         if remote and self.raise_opts:
  216.             # use autoraise argument only for remote invocation
  217.             autoraise = int(bool(autoraise))
  218.             opt = self.raise_opts[autoraise]
  219.             if opt: raise_opt = [opt]
  220.  
  221.         cmdline = [self.name] + raise_opt + args
  222.  
  223.         if remote or self.background:
  224.             inout = file(os.devnull, "r+")
  225.         else:
  226.             # for TTY browsers, we need stdin/out
  227.             inout = None
  228.         # if possible, put browser in separate process group, so
  229.         # keyboard interrupts don't affect browser as well as Python
  230.         setsid = getattr(os, 'setsid', None)
  231.         if not setsid:
  232.             setsid = getattr(os, 'setpgrp', None)
  233.  
  234.         p = subprocess.Popen(cmdline, close_fds=True, stdin=inout,
  235.                              stdout=(self.redirect_stdout and inout or None),
  236.                              stderr=inout, preexec_fn=setsid)
  237.         if remote:
  238.             # wait five secons. If the subprocess is not finished, the
  239.             # remote invocation has (hopefully) started a new instance.
  240.             time.sleep(1)
  241.             rc = p.poll()
  242.             if rc is None:
  243.                 time.sleep(4)
  244.                 rc = p.poll()
  245.                 if rc is None:
  246.                     return True
  247.             # if remote call failed, open() will try direct invocation
  248.             return not rc
  249.         elif self.background:
  250.             if p.poll() is None:
  251.                 return True
  252.             else:
  253.                 return False
  254.         else:
  255.             return not p.wait()
  256.  
  257.     def open(self, url, new=0, autoraise=1):
  258.         if new == 0:
  259.             action = self.remote_action
  260.         elif new == 1:
  261.             action = self.remote_action_newwin
  262.         elif new == 2:
  263.             if self.remote_action_newtab is None:
  264.                 action = self.remote_action_newwin
  265.             else:
  266.                 action = self.remote_action_newtab
  267.         else:
  268.             raise Error("Bad 'new' parameter to open(); " +
  269.                         "expected 0, 1, or 2, got %s" % new)
  270.  
  271.         args = [arg.replace("%s", url).replace("%action", action)
  272.                 for arg in self.remote_args]
  273.         success = self._invoke(args, True, autoraise)
  274.         if not success:
  275.             # remote invocation failed, try straight way
  276.             args = [arg.replace("%s", url) for arg in self.args]
  277.             return self._invoke(args, False, False)
  278.         else:
  279.             return True
  280.  
  281.  
  282. class Mozilla(UnixBrowser):
  283.     """Launcher class for Mozilla/Netscape browsers."""
  284.  
  285.     raise_opts = ["-noraise", "-raise"]
  286.  
  287.     remote_args = ['-remote', 'openURL(%s%action)']
  288.     remote_action = ""
  289.     remote_action_newwin = ",new-window"
  290.     remote_action_newtab = ",new-tab"
  291.  
  292.     background = True
  293.  
  294. Netscape = Mozilla
  295.  
  296.  
  297. class Galeon(UnixBrowser):
  298.     """Launcher class for Galeon/Epiphany browsers."""
  299.  
  300.     raise_opts = ["-noraise", ""]
  301.     remote_args = ['%action', '%s']
  302.     remote_action = "-n"
  303.     remote_action_newwin = "-w"
  304.  
  305.     background = True
  306.  
  307.  
  308. class Opera(UnixBrowser):
  309.     "Launcher class for Opera browser."
  310.  
  311.     raise_opts = ["", "-raise"]
  312.  
  313.     remote_args = ['-remote', 'openURL(%s%action)']
  314.     remote_action = ""
  315.     remote_action_newwin = ",new-window"
  316.     remote_action_newtab = ",new-page"
  317.     background = True
  318.  
  319.  
  320. class Elinks(UnixBrowser):
  321.     "Launcher class for Elinks browsers."
  322.  
  323.     remote_args = ['-remote', 'openURL(%s%action)']
  324.     remote_action = ""
  325.     remote_action_newwin = ",new-window"
  326.     remote_action_newtab = ",new-tab"
  327.     background = False
  328.  
  329.     # elinks doesn't like its stdout to be redirected -
  330.     # it uses redirected stdout as a signal to do -dump
  331.     redirect_stdout = False
  332.  
  333.  
  334. class Konqueror(BaseBrowser):
  335.     """Controller for the KDE File Manager (kfm, or Konqueror).
  336.  
  337.     See the output of ``kfmclient --commands``
  338.     for more information on the Konqueror remote-control interface.
  339.     """
  340.  
  341.     def open(self, url, new=0, autoraise=1):
  342.         # XXX Currently I know no way to prevent KFM from opening a new win.
  343.         if new == 2:
  344.             action = "newTab"
  345.         else:
  346.             action = "openURL"
  347.  
  348.         devnull = file(os.devnull, "r+")
  349.         # if possible, put browser in separate process group, so
  350.         # keyboard interrupts don't affect browser as well as Python
  351.         setsid = getattr(os, 'setsid', None)
  352.         if not setsid:
  353.             setsid = getattr(os, 'setpgrp', None)
  354.  
  355.         try:
  356.             p = subprocess.Popen(["kfmclient", action, url],
  357.                                  close_fds=True, stdin=devnull,
  358.                                  stdout=devnull, stderr=devnull)
  359.         except OSError:
  360.             # fall through to next variant
  361.             pass
  362.         else:
  363.             p.wait()
  364.             # kfmclient's return code unfortunately has no meaning as it seems
  365.             return True
  366.  
  367.         try:
  368.             p = subprocess.Popen(["konqueror", "--silent", url],
  369.                                  close_fds=True, stdin=devnull,
  370.                                  stdout=devnull, stderr=devnull,
  371.                                  preexec_fn=setsid)
  372.         except OSError:
  373.             # fall through to next variant
  374.             pass
  375.         else:
  376.             if p.poll() is None:
  377.                 # Should be running now.
  378.                 return True
  379.  
  380.         try:
  381.             p = subprocess.Popen(["kfm", "-d", url],
  382.                                  close_fds=True, stdin=devnull,
  383.                                  stdout=devnull, stderr=devnull,
  384.                                  preexec_fn=setsid)
  385.         except OSError:
  386.             return False
  387.         else:
  388.             return (p.poll() is None)
  389.  
  390.  
  391. class Grail(BaseBrowser):
  392.     # There should be a way to maintain a connection to Grail, but the
  393.     # Grail remote control protocol doesn't really allow that at this
  394.     # point.  It probably never will!
  395.     def _find_grail_rc(self):
  396.         import glob
  397.         import pwd
  398.         import socket
  399.         import tempfile
  400.         tempdir = os.path.join(tempfile.gettempdir(),
  401.                                ".grail-unix")
  402.         user = pwd.getpwuid(os.getuid())[0]
  403.         filename = os.path.join(tempdir, user + "-*")
  404.         maybes = glob.glob(filename)
  405.         if not maybes:
  406.             return None
  407.         s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
  408.         for fn in maybes:
  409.             # need to PING each one until we find one that's live
  410.             try:
  411.                 s.connect(fn)
  412.             except socket.error:
  413.                 # no good; attempt to clean it out, but don't fail:
  414.                 try:
  415.                     os.unlink(fn)
  416.                 except IOError:
  417.                     pass
  418.             else:
  419.                 return s
  420.  
  421.     def _remote(self, action):
  422.         s = self._find_grail_rc()
  423.         if not s:
  424.             return 0
  425.         s.send(action)
  426.         s.close()
  427.         return 1
  428.  
  429.     def open(self, url, new=0, autoraise=1):
  430.         if new:
  431.             ok = self._remote("LOADNEW " + url)
  432.         else:
  433.             ok = self._remote("LOAD " + url)
  434.         return ok
  435.  
  436.  
  437. #
  438. # Platform support for Unix
  439. #
  440.  
  441. # These are the right tests because all these Unix browsers require either
  442. # a console terminal or an X display to run.
  443.  
  444. def register_X_browsers():
  445.     # The default Gnome browser
  446.     if _iscommand("gconftool-2"):
  447.         # get the web browser string from gconftool
  448.         gc = 'gconftool-2 -g /desktop/gnome/url-handlers/http/command 2>/dev/null'
  449.         out = os.popen(gc)
  450.         commd = out.read().strip()
  451.         retncode = out.close()
  452.  
  453.         # if successful, register it
  454.         if retncode is None and commd:
  455.             register("gnome", None, BackgroundBrowser(commd.split()))
  456.  
  457.     # First, the Mozilla/Netscape browsers
  458.     for browser in ("mozilla-firefox", "firefox",
  459.                     "mozilla-firebird", "firebird",
  460.                     "seamonkey", "mozilla", "netscape"):
  461.         if _iscommand(browser):
  462.             register(browser, None, Mozilla(browser))
  463.  
  464.     # Konqueror/kfm, the KDE browser.
  465.     if _iscommand("kfm"):
  466.         register("kfm", Konqueror, Konqueror("kfm"))
  467.     elif _iscommand("konqueror"):
  468.         register("konqueror", Konqueror, Konqueror("konqueror"))
  469.  
  470.     # Gnome's Galeon and Epiphany
  471.     for browser in ("galeon", "epiphany"):
  472.         if _iscommand(browser):
  473.             register(browser, None, Galeon(browser))
  474.  
  475.     # Skipstone, another Gtk/Mozilla based browser
  476.     if _iscommand("skipstone"):
  477.         register("skipstone", None, BackgroundBrowser("skipstone"))
  478.  
  479.     # Opera, quite popular
  480.     if _iscommand("opera"):
  481.         register("opera", None, Opera("opera"))
  482.  
  483.     # Next, Mosaic -- old but still in use.
  484.     if _iscommand("mosaic"):
  485.         register("mosaic", None, BackgroundBrowser("mosaic"))
  486.  
  487.     # Grail, the Python browser. Does anybody still use it?
  488.     if _iscommand("grail"):
  489.         register("grail", Grail, None)
  490.  
  491. # Prefer X browsers if present
  492. if os.environ.get("DISPLAY"):
  493.     register_X_browsers()
  494.  
  495. # Also try console browsers
  496. if os.environ.get("TERM"):
  497.     # The Links/elinks browsers <http://artax.karlin.mff.cuni.cz/~mikulas/links/>
  498.     if _iscommand("links"):
  499.         register("links", None, GenericBrowser("links"))
  500.     if _iscommand("elinks"):
  501.         register("elinks", None, Elinks("elinks"))
  502.     # The Lynx browser <http://lynx.isc.org/>, <http://lynx.browser.org/>
  503.     if _iscommand("lynx"):
  504.         register("lynx", None, GenericBrowser("lynx"))
  505.     # The w3m browser <http://w3m.sourceforge.net/>
  506.     if _iscommand("w3m"):
  507.         register("w3m", None, GenericBrowser("w3m"))
  508.  
  509. #
  510. # Platform support for Windows
  511. #
  512.  
  513. if sys.platform[:3] == "win":
  514.     class WindowsDefault(BaseBrowser):
  515.         def open(self, url, new=0, autoraise=1):
  516.             os.startfile(url)
  517.             return True # Oh, my...
  518.  
  519.     _tryorder = []
  520.     _browsers = {}
  521.     # Prefer mozilla/netscape/opera if present
  522.     for browser in ("firefox", "firebird", "seamonkey", "mozilla",
  523.                     "netscape", "opera"):
  524.         if _iscommand(browser):
  525.             register(browser, None, BackgroundBrowser(browser))
  526.     register("windows-default", WindowsDefault)
  527.  
  528. #
  529. # Platform support for MacOS
  530. #
  531.  
  532. try:
  533.     import ic
  534. except ImportError:
  535.     pass
  536. else:
  537.     class InternetConfig(BaseBrowser):
  538.         def open(self, url, new=0, autoraise=1):
  539.             ic.launchurl(url)
  540.             return True # Any way to get status?
  541.  
  542.     register("internet-config", InternetConfig, update_tryorder=-1)
  543.  
  544. if sys.platform == 'darwin':
  545.     # Adapted from patch submitted to SourceForge by Steven J. Burr
  546.     class MacOSX(BaseBrowser):
  547.         """Launcher class for Aqua browsers on Mac OS X
  548.  
  549.         Optionally specify a browser name on instantiation.  Note that this
  550.         will not work for Aqua browsers if the user has moved the application
  551.         package after installation.
  552.  
  553.         If no browser is specified, the default browser, as specified in the
  554.         Internet System Preferences panel, will be used.
  555.         """
  556.         def __init__(self, name):
  557.             self.name = name
  558.  
  559.         def open(self, url, new=0, autoraise=1):
  560.             assert "'" not in url
  561.             # hack for local urls
  562.             if not ':' in url:
  563.                 url = 'file:'+url
  564.  
  565.             # new must be 0 or 1
  566.             new = int(bool(new))
  567.             if self.name == "default":
  568.                 # User called open, open_new or get without a browser parameter
  569.                 script = 'open location "%s"' % url.replace('"', '%22') # opens in default browser
  570.             else:
  571.                 # User called get and chose a browser
  572.                 if self.name == "OmniWeb":
  573.                     toWindow = ""
  574.                 else:
  575.                     # Include toWindow parameter of OpenURL command for browsers
  576.                     # that support it.  0 == new window; -1 == existing
  577.                     toWindow = "toWindow %d" % (new - 1)
  578.                 cmd = 'OpenURL "%s"' % url.replace('"', '%22')
  579.                 script = '''tell application "%s"
  580.                                 activate
  581.                                 %s %s
  582.                             end tell''' % (self.name, cmd, toWindow)
  583.             # Open pipe to AppleScript through osascript command
  584.             osapipe = os.popen("osascript", "w")
  585.             if osapipe is None:
  586.                 return False
  587.             # Write script to osascript's stdin
  588.             osapipe.write(script)
  589.             rc = osapipe.close()
  590.             return not rc
  591.  
  592.     # Don't clear _tryorder or _browsers since OS X can use above Unix support
  593.     # (but we prefer using the OS X specific stuff)
  594.     register("MacOSX", None, MacOSX('default'), -1)
  595.  
  596.  
  597. #
  598. # Platform support for OS/2
  599. #
  600.  
  601. if sys.platform[:3] == "os2" and _iscommand("netscape"):
  602.     _tryorder = []
  603.     _browsers = {}
  604.     register("os2netscape", None,
  605.              GenericBrowser(["start", "netscape", "%s"]), -1)
  606.  
  607.  
  608. # OK, now that we know what the default preference orders for each
  609. # platform are, allow user to override them with the BROWSER variable.
  610. if "BROWSER" in os.environ:
  611.     _userchoices = os.environ["BROWSER"].split(os.pathsep)
  612.     _userchoices.reverse()
  613.  
  614.     # Treat choices in same way as if passed into get() but do register
  615.     # and prepend to _tryorder
  616.     for cmdline in _userchoices:
  617.         if cmdline != '':
  618.             _synthesize(cmdline, -1)
  619.     cmdline = None # to make del work if _userchoices was empty
  620.     del cmdline
  621.     del _userchoices
  622.  
  623. # what to do if _tryorder is now empty?
  624.  
  625.  
  626. def main():
  627.     import getopt
  628.     usage = """Usage: %s [-n | -t] url
  629.     -n: open new window
  630.     -t: open new tab""" % sys.argv[0]
  631.     try:
  632.         opts, args = getopt.getopt(sys.argv[1:], 'ntd')
  633.     except getopt.error, msg:
  634.         print >>sys.stderr, msg
  635.         print >>sys.stderr, usage
  636.         sys.exit(1)
  637.     new_win = 0
  638.     for o, a in opts:
  639.         if o == '-n': new_win = 1
  640.         elif o == '-t': new_win = 2
  641.     if len(args) <> 1:
  642.         print >>sys.stderr, usage
  643.         sys.exit(1)
  644.  
  645.     url = args[0]
  646.     open(url, new_win)
  647.  
  648.     print "\a"
  649.  
  650. if __name__ == "__main__":
  651.     main()
  652.